package cn.com.zp.util.base;

import java.io.File;
import java.util.StringTokenizer;

/**
 * 字符串工具箱
 * 
 */
public final class StringUtils {
	/**
	 * 将一个字符串的首字母改为大写或者小写
	 * 
	 * @param srcString
	 *            源字符串
	 * @param flag
	 *            大小写标识，ture小写，false大些
	 * @return 改写后的新字符串
	 */
	public static String toLowerCaseInitial(String srcString, boolean flag) {
		StringBuilder sb = new StringBuilder();
		if (flag) {
			sb.append(Character.toLowerCase(srcString.charAt(0)));
		} else {
			sb.append(Character.toUpperCase(srcString.charAt(0)));
		}
		sb.append(srcString.substring(1));
		return sb.toString();
	}

	/**
	 * 将一个字符串按照句点（.）分隔，返回最后一段
	 * 
	 * @param clazzName
	 *            源字符串
	 * @return 句点（.）分隔后的最后一段字符串
	 */
	public static String getLastName(String clazzName) {
		String[] ls = clazzName.split("\\.");
		return ls[ls.length - 1];
	}

	/**
	 * 格式化文件路径，将其中不规范的分隔转换为标准的分隔符,并且去掉末尾的"/"符号。
	 * 
	 * @param path
	 *            文件路径
	 * @return 格式化后的文件路径
	 */
	public static String formatPath(String path) {
		String reg = "\\\\ |/ ";
		String temp = path.trim().replaceAll(reg, "/");
		if (temp.endsWith("/")) {
			return temp.substring(0, temp.length() - 1);
		}
		return temp;
	}

	/**
	 * 获取文件父路径
	 * 
	 * @param path
	 *            文件路径
	 * @return 文件父路径
	 */
	public static String getParentPath(String path) {
		return new File(path).getParent();
	}

	/**
	 * 获取相对路径
	 * 
	 * @param fullPath
	 *            全路径
	 * @param rootPath
	 *            根路径
	 * @return 相对根路径的相对路径
	 */
	public static String getRelativeRootPath(String fullPath, String rootPath) {
		String relativeRootPath = null;
		String _fullPath = formatPath(fullPath);
		String _rootPath = formatPath(rootPath);

		if (_fullPath.startsWith(_rootPath)) {
			relativeRootPath = fullPath.substring(_rootPath.length());
		} else {
			throw new RuntimeException("要处理的两个字符串没有包含关系，处理失败！");
		}
		if (relativeRootPath == null)
			return null;
		else
			return formatPath(relativeRootPath);
	}
	
	public static String trimToBlank(String str){
		return str.trim();
	}
	
	/**
	 * 将字节数组转换成十六进制的字符串
	 * 
	 * @param bytes
	 * @return
	 */
	public static String byteToHex(byte[] bytes) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < bytes.length; i++) {
			int num = 0xFF & bytes[i];
			if (num < 0x10) {
				sb.append("0" + Integer.toHexString(num));
			} else {
				sb.append(Integer.toHexString(num));
			}
		}
		return sb.toString();
	}
	
	/***
	 * 过滤字符串中出现的空格，此方法最简单
	 * 
	 * @param str
	 * @return
	 */
	public static String filterBlankWord(String str) {
		str = str.replaceAll(" ", "");
		return str;
	}

	/***
	 * 过滤字符串中出现的空格，使用StringTokenizer类效率最高
	 * 
	 * @param str
	 * @return
	 */
	public static String filterBlankWord1(String str) {
		StringTokenizer st = new StringTokenizer(str, " ");
		StringBuffer sb = new StringBuffer(); // StringBuffer类在处理字符串连接时比String效率高
		while (st.hasMoreTokens()) {
			System.out.println(sb.append(st.nextToken()));
		}
		return sb.toString();
	}
	
	
}
